import 'package:FlutterStudy/BaseWidgget.dart'; // 假设存在
import 'package:FlutterStudy/demo/navigator/Home.dart'; // 假设存在
import 'package:FlutterStudy/demo/navigator/detail.dart'; // 假设存在
import 'package:FlutterStudy/utils/splash.dart'; // 假设存在
import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';

import 'Flutter Navigator 2.0 Web Back Button Example.dart';

void main() {
  runApp(BiliApp());
}

class BiliApp extends StatefulWidget with Splash {
  @override
  _BiliAppState createState() => _BiliAppState();
}

class _BiliAppState extends State<BiliApp> {
  final BiliRouteDelegate _routeDelegate = BiliRouteDelegate(); // 使用 final
  final BiliRouteInformationParse _informationParse =
      BiliRouteInformationParse(); // 使用 final

  @override
  Widget build(BuildContext context) {
    hideScreen(); // 启动屏隐藏
    return MaterialApp.router(
      title: 'Flutter Navigator 2.0 Web Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      routeInformationParser: _informationParse,
      routerDelegate: _routeDelegate,
      // 确保使用PlatformRouteInformationProvider来处理Web上的URL
      routeInformationProvider: PlatformRouteInformationProvider(
        initialRouteInformation:  RouteInformation(uri: Uri.parse('/')),
      ),
    );
  }
}

class BiliRouteDelegate extends RouterDelegate<BiliRoutePath>
    with PopNavigatorRouterDelegateMixin<BiliRoutePath>, ChangeNotifier {
  // navigatorKey 必须是持久的 final 实例
  // final GlobalKey<NavigatorState> mNavigatorKey ;

  final GlobalKey<NavigatorState> _navigatorKey;

  BiliRouteDelegate() : _navigatorKey = GlobalKey<NavigatorState>();

  BiliRoutePath _currentPath =
      BiliRoutePath.home(); // 使用私有变量，通过 getter/setter 或方法修改





  @override
  Widget build(BuildContext context) {
    // 每次 build 时，根据当前状态重新构建 pages 列表
    List<Page> currentPages = [
      const MaterialPage(key: ValueKey('HomePage'), child: Home()),
    ];
    if (_currentPath.location == "/detail") {
      currentPages.add(
        MaterialPage(
          key: ValueKey(_currentPath.location),
          child: const Detail(),
        ),
      );
    }

    return Navigator(
      key: navigatorKey,
      pages: currentPages,
      onPopPage: (route, result) {
        print("onPopPage${route}");
        // 如果页面没有成功弹出，则返回 false
        if (!route.didPop(result)) {
          return false;
        }

        // 如果当前是详情页，并且它被弹出了（例如，通过 Navigator.pop 或系统返回键）
       /* if (isShowDetail) {
          isShowDetail = false; // 更新状态
          return true; // 表示我们已经处理了这次弹出
        }*/
        return false; // 对于其他情况，让 Navigator 继续处理
      },
    );

    /* return PopScope(
      // canPop 决定系统返回键是否允许 Navigator 弹出页面。
      // 如果在详情页，我们希望通过 onPopPage/onPopInvokedWithResult 来控制状态，所以这里可以设置为 false
      // 或者设置为 !isShowDetail，表示在主页时允许系统直接退出应用，在详情页时由我们控制
      canPop: !isShowDetail,
      onPopInvokedWithResult: (didPop, result) {
        print("onPopInvokedWithResult - didPop: $didPop");
        // 如果系统返回键尝试弹出，并且我们当前在详情页
        if (!didPop && isShowDetail) {
          isShowDetail = false; // 更新状态
          notifyListeners();
        }
      },
      child: Navigator(
        key: navigatorKey,
        pages: currentPages,
        onDidRemovePage: (page){
          print("onDidRemovePage ${page}");
        },
        onPopPage: (route, result) {
          // 如果页面没有成功弹出，则返回 false
          if (!route.didPop(result)) {
            return false;
          }

          // 如果当前是详情页，并且它被弹出了（例如，通过 Navigator.pop 或系统返回键）
          if (isShowDetail) {
            isShowDetail = false; // 更新状态
            return true; // 表示我们已经处理了这次弹出
          }
          return false; // 对于其他情况，让 Navigator 继续处理
        },

      ),
    );*/
  }

  @override
  GlobalKey<NavigatorState> get navigatorKey => _navigatorKey;

  @override
  Future<void> setNewRoutePath(BiliRoutePath configuration) async {
    print('当浏览器URL改变时: ${configuration.location}');
    /*  if (configuration.location == '/') {
      _currentPath = configuration;
    } else if (configuration.location == '/detail') {
      _currentPath = configuration;
    }else{
      _currentPath = configuration;
    }*/
    _currentPath = configuration;
    notifyListeners();

    // 注意：isShowDetail 的 setter 已经包含了 notifyListeners()
  }

  @override
  BiliRoutePath get currentConfiguration {
    return _currentPath;
  }

  void showDetail() {
    _currentPath = BiliRoutePath.detail();
    notifyListeners();
  }

  void showHome() {
    _currentPath = BiliRoutePath.home();
    notifyListeners();
  }

  static BiliRouteDelegate of(BuildContext context) {

    final delegate = Router.of(context).routerDelegate;
    assert(delegate is BiliRouteDelegate, 'Delegate type must match');
    return delegate as BiliRouteDelegate;
  }

  @override
  Future<bool> popRoute() {
    print('弹出事件');
  /*  if (isShowDetail) {
      isShowDetail = false;
      notifyListeners();
      return SynchronousFuture(true); // 消费了弹出事件
    }
*/
    return SynchronousFuture(false); // 未消费弹出事件，让系统处理（例如退出应用）
  }
}

class BiliRouteInformationParse extends RouteInformationParser<BiliRoutePath> {
  @override
  Future<BiliRoutePath> parseRouteInformation(
    RouteInformation routeInformation,
  ) {
    Uri uri = routeInformation.uri;
    print("将URL路径解析为BiliRoutePath: ${routeInformation.uri.pathSegments}");
    if (uri.pathSegments.isEmpty) {
      // 检查 pathSegments 是否为空
      return SynchronousFuture(BiliRoutePath.home());
    } else if (uri.pathSegments.length == 1 &&
        uri.pathSegments[0] == 'detail') {
      return SynchronousFuture(BiliRoutePath.detail());
      ;
    }
    // 默认返回主页，或者可以抛出异常/返回一个未知路由
    return SynchronousFuture(BiliRoutePath.home());
    ;
  }

  @override
  RouteInformation? restoreRouteInformation(BiliRoutePath configuration) {
    // 这个方法在 Web 上很重要，用于将 RoutePath 转换回 RouteInformation
    print('将BiliRoutePath转回URL路径，用于更新浏览器URL: ${configuration.location}');
    return RouteInformation(uri: Uri.parse(configuration.location));
  }
}

/// 定义路由数据，path
class BiliRoutePath {
  final String location;

  BiliRoutePath.home() : location = "/";

  BiliRoutePath.detail() : location = "/detail";

  // 添加 equals 和 hashCode 以便在比较 RoutePath 时正确工作
  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      other is BiliRoutePath &&
          runtimeType == other.runtimeType &&
          location == other.location;

  @override
  int get hashCode => location.hashCode;
}
